5 research outputs found
Interactive program verification using virtual programs
This thesis is concerned with ways of proving the
correctness of computer programs. The first part of the
thesis presents a new method for doing this. The method,
called continuation induction, is based on the ideas of
symbolic execution, the description of a given program by a
virtual program, and the demonstration that these two
programs are equivalent whenever the given program
terminates. The main advantage of continuation induction
over other methods is that it enables programs using a wide
variety of programming constructs such as recursion,
iteration, non-determinism, procedures with side-effects and
jumps out of blocks to be handled in a natural and uniform
way. In the second part of the thesis a program verifier
which uses both this method and Floyd's inductive assertion
method is described. The significance of this verifier is
that it is designed to be extensible, and to this end the
user can declare new functions and predicates to be used in
giving a natural description of the program's intention.
Rules describing these new functions can then be used when
verifying the program. To actually prove the verification
conditions, the system employs automatic simplification, a
relatively clever matcher, a simple natural deduction system
and, most importantly, the user's advice. A large number of
commands are provided for the user in guiding the system to a proof of the program's correctness. The system has been
used to verify various programs including two sorting
programs and a program to invert a permutation 'in place' the proofs of the sorting programs included a proof of the fact that
the final array was a permutation of the original one.
Finally, some observations and suggestions are made
concerning the continued development of such interactive
verification systems
Concept and Role Forgetting in ALC Ontologies
Forgetting is an important tool for reducing ontologies by eliminating some concepts and roles while preserving sound and complete reasoning. Attempts have previously been made to address the problem of forgetting in relatively simple description logics (DLs) such as DL-Lite and extended . The ontologies used in these attempts were mostly restricted to TBoxes rather than general knowledge bases (KBs). However, the issue of forgetting for general KBs in more expressive description logics, such as and OWL DL, is largely unexplored. In particular, the problem of characterizing and computing forgetting for such logics is still open.
In this paper, we first define semantic forgetting about concepts and roles in ontologies and state several important properties of forgetting in this setting. We then define the result of forgetting for concept descriptions in , state the properties of forgetting for concept descriptions, and present algorithms for computing the result of forgetting for concept descriptions. Unlike the case of DL-Lite, the result of forgetting for an ontology does not exist in general, even for the special case of concept forgetting. This makes the problem of how to compute forgetting in more challenging. We address this problem by defining a series of approximations to the result of forgetting for ontologies and studying their properties and their application to reasoning tasks. We use the algorithms for computing forgetting for concept descriptions to compute these approximations. Our algorithms for computing approximations can be embedded into an ontology editor to enhance its ability to manage and reason in (large) ontologies